package priv.wangy.micro.common.thread;



import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author wangy
 * @since 2023-11-03
 */
public class ThreadPool extends ThreadPoolExecutor {

    /**
     * 声明单例对象
     */
    private volatile static ThreadPool pool;

    /**
     * 重写构造函数
     */
    private ThreadPool() {
        /*
         * 构造参数，估计没人会改，所以我替你们默认了
         * 如遇到确需变更的情况，可直接使用getter/setter方法
         * corePoolSize 核心线程池大小 int
         *   空闲状态的核心线程不会被回收，除非设置了 allowCoreThreadTimeOut
         *   核心线程池未满前，哪怕已存在的线程全部处于空闲状态，也会创建新的核心线程
         * maximumPoolSize 最大线程池大小 int
         * keepAliveTime 线程最大空闲时间 long
         * unit 时间单位 TimeUnit
         * workQueue 线程等待队列 BlockingQueue<Runnable>
         * threadFactory 线程创建工厂 ThreadFactory
         * handler 拒绝策略 RejectedExecutionHandler
         *   AbortPolicy：抛出异常 RejectedExecutionException (RuntimeException)
         *   DiscardPolicy：丢弃被拒绝的任务
         *   DiscardOldestPolicy：丢弃最早的未处理请求，然后重新尝试执行
         *   CallerRunsPolicy：直接在调用线程中执行任务
         */
        super(32, 256, 500L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024),
                new ThreadFactoryBuilder().setNameFormat("thread-pool-%d").build(),
                new AbortPolicy());
        /*
        确保执行完的核心线程被回收
        此时，keepAliveTime不可为0
         */
        this.allowCoreThreadTimeOut(true);
    }

    /**
     * 获取实例对象
     *
     * @return com.whminwei.printcert.util.ThreadPool
     * @author 张嘉琪
     * @since 2021-03-24
     */
    public static ThreadPool getPool() {
        if (pool == null || pool.isShutdown() || pool.isTerminated()) {
            synchronized (ThreadPool.class) {
                if (pool == null || pool.isShutdown() || pool.isTerminated()) {
                    pool = new ThreadPool();
                }
            }
        }
        return pool;
    }
}
